const { Cart, Product, User } = require('@models');
const { ApiResponse } = require('@shared/utils/response');
const sequelize = require('@shared/utils/database');

/**
 * 添加商品到购物车
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.addToCart = async (req, res) => {
  const transaction = await sequelize.transaction();
  
  try {
    const userId = req.user.id;
    const { productId, quantity = 1 } = req.body;
    
    console.log(`[购物车] 添加商品请求 - 用户ID: ${userId}, 商品ID: ${productId}, 数量: ${quantity}`);
    
    if (!productId) {
      console.error(`[购物车] 商品ID为空`);
      return res.status(400).json({
        code: 400,
        message: '商品ID不能为空'
      });
    }
    
    // 检查商品是否存在
    const product = await Product.findByPk(productId);
    if (!product) {
      console.error(`[购物车] 商品不存在 - 商品ID: ${productId}`);
      return res.status(404).json({
        code: 404,
        message: '商品不存在'
      });
    }
    
    // 检查商品是否已上架
    if (product.status !== 1) {
      console.error(`[购物车] 商品已下架 - 商品ID: ${productId}, 状态: ${product.status}`);
      return res.status(400).json({
        code: 400,
        message: '商品已下架'
      });
    }
    
    console.log(`[购物车] 用户 ${userId} 添加商品 ${productId} 到购物车，数量: ${quantity}`);
    
    // 查询购物车中是否已有该商品
    let cartItem = await Cart.findOne({
      where: {
        user_id: userId,
        product_id: productId
      }
    });
    
    if (cartItem) {
      // 如果商品已在购物车中，更新数量
      const newQuantity = cartItem.quantity + Number(quantity);
      
      // 更新购物车商品数量
      await cartItem.update({
        quantity: newQuantity
      }, { transaction });
      
      console.log(`购物车商品${productId}数量更新为${newQuantity}`);
    } else {
      // 如果商品不在购物车中，新增记录
      cartItem = await Cart.create({
        user_id: userId,
        product_id: productId,
        quantity: Number(quantity),
        selected: 1
      }, { transaction });
      
      console.log(`新增购物车商品${productId}`);
    }
    
    await transaction.commit();
    
    return res.json({
      code: 200,
      message: '添加成功',
      data: {
        id: cartItem.id,
        quantity: cartItem.quantity
      }
    });
  } catch (error) {
    await transaction.rollback();
    console.error('添加购物车失败:', error);
    
    return res.status(500).json({
      code: 500,
      message: '服务器内部错误'
    });
  }
};

/**
 * 获取购物车列表
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.getCart = async (req, res) => {
  try {
    const userId = req.user.id;
    
    // 查询购物车商品
    const cartItems = await Cart.findAll({
      where: {
        user_id: userId
      },
      include: [
        {
          model: Product,
          attributes: ['id', 'name', 'price', 'cover', 'stock']
        }
      ]
    });
    
    // 格式化结果
    const formattedItems = cartItems.map(item => ({
      id: item.id,
      productId: item.product_id,
      name: item.Product.name,
      price: item.Product.price,
      cover: item.Product.cover,
      stock: item.Product.stock,
      quantity: item.quantity,
      selected: item.selected === 1
    }));
    
    return res.json({
      code: 200,
      message: '获取成功',
      data: formattedItems
    });
  } catch (error) {
    console.error('获取购物车失败:', error);
    
    return res.status(500).json({
      code: 500,
      message: '服务器内部错误'
    });
  }
};

/**
 * 更新购物车商品数量
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.updateCartItem = async (req, res) => {
  try {
    const { id } = req.params;
    const { quantity } = req.body;
    const userId = req.user.id;
    
    if (!quantity || quantity < 1) {
      return res.status(400).json({
        code: 400,
        message: '数量必须大于0'
      });
    }
    
    // 查询购物车商品
    const cartItem = await Cart.findOne({
      where: {
        id,
        user_id: userId
      }
    });
    
    if (!cartItem) {
      return res.status(404).json({
        code: 404,
        message: '购物车商品不存在'
      });
    }
    
    // 更新数量
    await cartItem.update({
      quantity
    });
    
    return res.json({
      code: 200,
      message: '更新成功',
      data: {
        id: cartItem.id,
        quantity: cartItem.quantity
      }
    });
  } catch (error) {
    console.error('更新购物车失败:', error);
    
    return res.status(500).json({
      code: 500,
      message: '服务器内部错误'
    });
  }
};

/**
 * 删除购物车商品
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.removeCartItem = async (req, res) => {
  try {
    const { id } = req.params;
    const userId = req.user.id;
    
    // 查询购物车商品
    const cartItem = await Cart.findOne({
      where: {
        id,
        user_id: userId
      }
    });
    
    if (!cartItem) {
      return res.status(404).json({
        code: 404,
        message: '购物车商品不存在'
      });
    }
    
    // 删除购物车商品
    await cartItem.destroy();
    
    return res.json({
      code: 200,
      message: '删除成功'
    });
  } catch (error) {
    console.error('删除购物车失败:', error);
    
    return res.status(500).json({
      code: 500,
      message: '服务器内部错误'
    });
  }
};

/**
 * 获取购物车商品数量
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.getCartCount = async (req, res) => {
  try {
    const userId = req.user.id;
    
    // 查询购物车商品总数
    const count = await Cart.sum('quantity', {
      where: {
        user_id: userId
      }
    });
    
    console.log(`[购物车] 用户 ${userId} 的购物车商品总数: ${count || 0}`);
    
    return res.json({
      code: 200,
      message: '获取成功',
      data: count || 0
    });
  } catch (error) {
    console.error('获取购物车商品数量失败:', error);
    
    return res.status(500).json({
      code: 500,
      message: '服务器内部错误'
    });
  }
};

/**
 * 更新购物车商品选中状态
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.updateCartItemSelected = async (req, res) => {
  try {
    const { id } = req.params;
    const { selected } = req.body;
    const userId = req.user.id;
    
    console.log(`[购物车] 更新商品选中状态 - 用户ID: ${userId}, 商品ID: ${id}, 选中状态: ${selected}`);
    
    if (selected === undefined) {
      return res.status(400).json({
        code: 400,
        message: '选中状态不能为空'
      });
    }
    
    // 查询购物车商品
    const cartItem = await Cart.findOne({
      where: {
        id,
        user_id: userId
      }
    });
    
    if (!cartItem) {
      return res.status(404).json({
        code: 404,
        message: '购物车商品不存在'
      });
    }
    
    // 更新选中状态
    await cartItem.update({
      selected: selected ? 1 : 0
    });
    
    console.log(`[购物车] 商品 ${id} 选中状态更新为 ${selected ? '已选中' : '未选中'}`);
    
    return res.json({
      code: 200,
      message: '更新成功',
      data: {
        id: cartItem.id,
        selected: selected ? 1 : 0
      }
    });
  } catch (error) {
    console.error('更新购物车商品选中状态失败:', error);
    
    return res.status(500).json({
      code: 500,
      message: '服务器内部错误'
    });
  }
};

/**
 * 批量更新购物车商品选中状态
 * @param {Object} req - 请求对象
 * @param {Object} res - 响应对象
 */
exports.updateAllCartItemsSelected = async (req, res) => {
  const transaction = await sequelize.transaction();
  
  try {
    const { selected } = req.body;
    const userId = req.user.id;
    
    console.log(`[购物车] 批量更新商品选中状态 - 用户ID: ${userId}, 选中状态: ${selected}`);
    
    if (selected === undefined) {
      return res.status(400).json({
        code: 400,
        message: '选中状态不能为空'
      });
    }
    
    // 更新该用户所有购物车商品的选中状态
    await Cart.update(
      { selected: selected ? 1 : 0 },
      { 
        where: { user_id: userId },
        transaction
      }
    );
    
    await transaction.commit();
    
    console.log(`[购物车] 用户 ${userId} 的所有商品选中状态更新为 ${selected ? '已选中' : '未选中'}`);
    
    return res.json({
      code: 200,
      message: '更新成功'
    });
  } catch (error) {
    await transaction.rollback();
    console.error('批量更新购物车商品选中状态失败:', error);
    
    return res.status(500).json({
      code: 500,
      message: '服务器内部错误'
    });
  }
}; 